Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.


QTRS
  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> BUSY7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> OR2(b3, i3)
START1(i) -> BUSY7(F, closed, stop, false, false, false, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> OR2(b2, i2)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> OR2(b1, i1)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ DependencyPairsProof
QDP
      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> BUSY7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> OR2(b3, i3)
START1(i) -> BUSY7(F, closed, stop, false, false, false, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> OR2(b2, i2)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> OR2(b1, i1)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 1 SCC with 4 less nodes.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
QDP
          ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> BUSY7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> BUSY7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
The remaining pairs can at least be oriented weakly.

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
Used ordering: Polynomial interpretation [21]:

POL(B) = 0   
POL(BF) = 0   
POL(BUSY7(x1, x2, x3, x4, x5, x6, x7)) = x7   
POL(F) = 0   
POL(FS) = 0   
POL(IDLE7(x1, x2, x3, x4, x5, x6, x7)) = x2 + x7   
POL(S) = 0   
POL(closed) = 0   
POL(down) = 0   
POL(empty) = 0   
POL(false) = 0   
POL(newbuttons4(x1, x2, x3, x4)) = 1 + x3 + x4   
POL(open) = 0   
POL(or2(x1, x2)) = 0   
POL(stop) = 0   
POL(true) = 0   
POL(up) = 0   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ QDP
          ↳ QDPOrderProof
QDP
              ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 1 SCC with 3 less nodes.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ QDP
          ↳ QDPOrderProof
            ↳ QDP
              ↳ DependencyGraphProof
QDP
                  ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
The remaining pairs can at least be oriented weakly.

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
Used ordering: Polynomial interpretation [21]:

POL(B) = 0   
POL(BF) = 0   
POL(BUSY7(x1, x2, x3, x4, x5, x6, x7)) = x4 + x7   
POL(F) = 0   
POL(FS) = 0   
POL(IDLE7(x1, x2, x3, x4, x5, x6, x7)) = x1 + x2 + x4   
POL(S) = 0   
POL(closed) = 0   
POL(down) = 0   
POL(empty) = 0   
POL(false) = 0   
POL(open) = 0   
POL(stop) = 0   
POL(true) = 1   
POL(up) = 0   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ QDP
          ↳ QDPOrderProof
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ QDPOrderProof
QDP
                      ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
The remaining pairs can at least be oriented weakly.

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
Used ordering: Polynomial interpretation [21]:

POL(B) = 0   
POL(BF) = 0   
POL(BUSY7(x1, x2, x3, x4, x5, x6, x7)) = x5 + x6   
POL(F) = 0   
POL(FS) = 0   
POL(IDLE7(x1, x2, x3, x4, x5, x6, x7)) = x5 + x6   
POL(S) = 0   
POL(closed) = 0   
POL(down) = 0   
POL(empty) = 0   
POL(false) = 0   
POL(open) = 0   
POL(stop) = 0   
POL(true) = 1   
POL(up) = 0   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ QDP
          ↳ QDPOrderProof
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ QDPOrderProof
                    ↳ QDP
                      ↳ QDPOrderProof
QDP
                          ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
The remaining pairs can at least be oriented weakly.

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
Used ordering: Polynomial interpretation [21]:

POL(B) = 0   
POL(BF) = 0   
POL(BUSY7(x1, x2, x3, x4, x5, x6, x7)) = x2 + x5   
POL(F) = 0   
POL(FS) = 0   
POL(IDLE7(x1, x2, x3, x4, x5, x6, x7)) = x2 + x5   
POL(S) = 0   
POL(closed) = 0   
POL(down) = 0   
POL(empty) = 0   
POL(false) = 0   
POL(open) = 1   
POL(stop) = 0   
POL(true) = 0   
POL(up) = 0   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ QDP
          ↳ QDPOrderProof
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ QDPOrderProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ QDPOrderProof
QDP

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.